const util = require('../utils/util.js')
const sizhu = require('../sizhu/sizhu.js')
const log = require('../log/log.js')
const app = getApp();

//十个天干       0     1     2     3    4     5     6     7    8     9
const tgArr = ["甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸"]
//十二个地支     0     1     2     3    4     5     6     7     8     9    10   11
const dzArr = ["子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥"]
//十二个五行     0     1     2     3    4     5     6     7     8     9    10   11
const dzPArr = ["水", "土", "木", "木", "土", "火", "火", "土", "金", "金", "土", "水"]
//旬空顺序
const emptyArr = ["戌 亥", "申 酉", "午 未", "辰 巳", "寅 卯", "子 丑"]
//六神顺序
const sixGodArr = ["青龙", "朱雀", "勾陈", "螣蛇", "白虎", "玄武"]
//乾坤八卦数组
const baGuaArr = ["乾", "兑", "离", "震", "巽", "坎", "艮", "坤"]
//乾坎纳甲
const baGuaNaJiaArr = ["乾", "坤", "艮", "兑", "坎", "离", "震", "巽", "乾", "坤"]
//十个天干               0     1     2     3    4     5     6     7     8    9
const baGuaPArr = ["金", "金", "火", "木", "木", "水", "土", "土"]
//五行               0    1     2     3     4
const wuXingArr = ["木", "火", "土", "金", "水"]
//用神
//   0       1      2       3       4
const yongShenArr = ["兄弟", "子孙", "妻财", "官鬼", "父母"]
//世应,世应间隔2
const shiYingArr = [5, 0, 1, 2, 3, 4, 3, 2]
//64卦名称
const naJiaNameArr = [
    ["乾为天(六冲)", "天风姤", "天山遁", "天地否(六合)", "风地观", "山地剥", "火地晋", "火天大有"],
    ["兑为泽(六冲)", "泽水困(六合)", "泽地萃", "泽山咸", "水山蹇", "地山谦", "雷山小过", "雷泽归妹"],
    ["离为火(六冲)", "火山旅(六合)", "火风鼎", "火水未济", "山水蒙", "风水涣", "天水讼", "天火同人"],
    ["震为雷(六冲)", "雷地豫(六合)", "雷水解", "雷风恒", "地风升", "水风井", "泽风大过", "泽雷随"],
    ["巽为风(六冲)", "风天小畜", "风火家人", "风雷益", "天雷无妄(六冲)", "火雷噬嗑", "山雷颐", "山风蛊"],
    ["坎为水(六冲)", "水泽节(六合)", "水雷屯", "水火既济", "泽火革", "雷火丰", "地火明夷", "地水师"],
    ["艮为山(六冲)", "山火贲(六合)", "山天大畜", "山泽损", "火泽睽", "天泽履", "风泽中孚", "风山渐"],
    ["坤为地(六冲)", "地雷复(六合)", "地泽临", "地天泰(六合)", "雷天大壮(六冲)", "泽天夬", "水天需", "水地比"]
]
//旬空表
const kongArr = [" ", "空"]
//表
const chongArr = ["值", "临", "合", "冲"]
//旺相休囚死
const keArr = ["旺", "相", "死", "囚", "休"]
//木：亥，火：寅，土：申，金：巳，水：申
const startTlvArr = [11, 2, 8, 5, 8]
//生旺墓绝
const tlvArr = ["生", "浴", "带", "官", "旺", "衰", "病", "死", "墓", "绝", "胎", "养"]
//化进、化退、化生、化克、化合、化冲
const htArr = ["进", "退", "生", "克", "合", "冲"]
//四库之地
const fkArr = [1, 4, 7, 10]
//四败之地
const fbArr = [2, 5, 8, 11]

//神煞
const xingShaArr = ["贵人", "禄神", "羊刃", "文昌", "驿马", "桃花", "将星", "劫煞", "华盖", "谋星", "天医", "天喜", "灾煞"]
const xingShaRule = [
    { "name": "贵人", "type": 0, "ganZhi": [[0, 4], [1, 5], [2, 3], [6, 7], [8, 9]], "shaZhi": [[1, 7], [0, 8], [9, 11], [2, 6], [3, 5]] },
    { "name": "禄神", "type": 0, "ganZhi": [[0], [1], [2, 4], [3, 5], [6], [7], [8], [9]], "shaZhi": [[2], [3], [5], [6], [8], [9], [11], [0]] },
    { "name": "羊刃", "type": 0, "ganZhi": [[0], [1], [2, 4], [3, 5], [6], [7], [8], [9]], "shaZhi": [[3], [2], [6], [5], [9], [8], [0], [11]] },
    { "name": "文昌", "type": 0, "ganZhi": [[0], [1], [2, 4], [3, 5], [6], [7], [8], [9]], "shaZhi": [[5], [6], [8], [9], [11], [0], [2], [3]] },
    { "name": "驿马", "type": 1, "ganZhi": [[0, 4, 8], [1, 5, 9], [2, 6, 10], [3, 7, 11]], "shaZhi": [[2], [11], [8], [5]] },
    { "name": "桃花", "type": 1, "ganZhi": [[0, 4, 8], [1, 5, 9], [2, 6, 10], [3, 7, 11]], "shaZhi": [[9], [6], [3], [0]] },
    { "name": "将星", "type": 1, "ganZhi": [[0, 4, 8], [1, 5, 9], [2, 6, 10], [3, 7, 11]], "shaZhi": [[0], [9], [6], [3]] },
    { "name": "劫煞", "type": 1, "ganZhi": [[0, 4, 8], [1, 5, 9], [2, 6, 10], [3, 7, 11]], "shaZhi": [[5], [2], [11], [8]] },
    { "name": "华盖", "type": 1, "ganZhi": [[0, 4, 8], [1, 5, 9], [2, 6, 10], [3, 7, 11]], "shaZhi": [[4], [1], [10], [7]] },
    { "name": "谋星", "type": 1, "ganZhi": [[0, 4, 8], [1, 5, 9], [2, 6, 10], [3, 7, 11]], "shaZhi": [[10], [7], [4], [1]] },
    { "name": "天医", "type": 3, "ganZhi": [[0], [1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [11]], "shaZhi": [[11], [0], [1], [2], [3], [4], [5], [6], [7], [8], [9], [10]] },
    { "name": "天喜", "type": 3, "ganZhi": [[2, 3, 4], [5, 6, 7], [8, 9, 10], [11, 0, 1]], "shaZhi": [[10], [1], [4], [7]] },
    { "name": "灾煞", "type": 1, "ganZhi": [[0, 4, 8], [1, 5, 9], [2, 6, 10], [3, 7, 11]], "shaZhi": [[6], [3], [0], [9]] }
]

/******************************************爻位纳音*************************************** */
const shenShaNaYin = [
    "贵人：寓意与个人、社交、人际相关的星煞。",
    "禄神：寓意财禄、待遇、饮食、生活、收益、回报、非专业等方面的星煞。",
    "羊刃：寓意工作、单位、物件、器质、利器、项目、维护、专业性等方面的星煞。",
    "文昌：寓意技能、能力、水平、聪明、策划、难度、技术性等方面的星煞。",
    "驿马：寓意奔波、远近、流动性、动静性质等方面的星煞。",
    "桃花：寓意女性、孩子、感情、装潢、广告、条文、门面、学历、荣耀等方面的星煞。",
    "将星：寓意核心、重要性、程度、幅度、效率等方面的星煞。",
    "劫煞：寓意难关、阻碍、祸患、劫数、问题、烦恼等方面的星煞。",
    "华盖：寓意被动、无奈、聪明、迥异、怪僻、个性等方面的星煞。",
    "谋星：寓意主动性的计划、谋划、策划、打算、预期等方面的星煞。",
    "天医：寓意疾病、医药、医学、医生、保养等方面的星煞。",
    "天喜：寓意喜事、喜庆、好事、商业、铺面、热闹、节假、旅游、玩乐等方面的星煞。",
    "灾煞：也是寓意难关、阻碍、劫数、问题、麻烦等专指近段即将出现问题或阻滞预兆方面的星煞。"
]

/******************************************爻位纳音*************************************** */
const yaoNumNaYin = [
    "六爻：头发、大脑、企业文化、精神、天花板、屋顶、宇宙、自然之事",
    "五爻：头、五官、总经理、老板、外面的路、国家大事",
    "四爻：胸部、总监、副总、总裁、大门、窗户、公事",
    "三爻：腹部、经理、卧室、床、人事",
    "二爻：腿、膝盖、小主管、厨房、炉灶、家事",
    "初爻：脚、一线员工、地板、地基、心事"
]

/******************************************六神纳音*************************************** */
const sixGodNaYin = [
    "青龙：吉庆，顺利，喜事，主男女婚姻之事，怀孕，生子；青龙又主色情，好色，色欲，钱财，贵人，富人，官贵，有能力的人，领导干部，负责人，名门，聪明，文雅，亮丽，左边，木，酒色，娱乐，雨等。",
    "朱雀：口舌，是非，唇齿，声音，唱歌，口才，说笑，声音，声响，语言，大呼小叫，纠纷，诉讼，口舌争斗；朱雀又代表电子，电话，电灯；朱雀又代表文人，老师，律师，学校，文书，电信，信件，信息，消息，电报，前方，飞鸟，火光，火星，脾气火暴，光明，人多热闹，活泼，性急等。",
    "勾陈：田土，田园，住宅，房屋，山地，建造，动土，动工，拆迁，农作物，五谷杂粮，牢狱之灾，性格顽固，死板，安静，动少静多，人物性格，黑、内向，老实，迟，慢，勾连，勾结，牵连，牵挂，缠身，中间，拘留，诉讼，争吵，官诉，劳改场，打斗等。",
    "腾蛇：虚多实少，变来变去，狡猾，不真实，多用心机，猜疑，思考问题多，做梦，心乱如麻，不爽快，隐藏而不吐真情，绳子，带子，长形物体，缠住，牵挂，麻烦，难缠的人，光滑，变化，多变幻，性情难测，怪异，吃惊，意外，惊吓，坐立不安，心神不宁，精神不安，胡思乱想，聪明，做梦惊吓，阴暗，夜里，小人，失眠，难睡，路等。",
    "白虎：性情狠毒，残暴，凶猛，心毒，性急，刚强，好勇，果断，豪爽，脾气暴躁，强暴，身体强壮，冲突，争强好胜，打架，血光之灾，打人，军人，警察，公门中人，刑法，官方，警卫，保安，律师，髙层领导人；白虎又主凶，恶，灾难，凶事，危险，损伤，破坏，伤残，破旧，刀枪，手术，开刀，刀剑子弹；白虎又主死亡，丧命，重病，医院，看病，兵器，砍杀，凶杀，伤亡，血，见血，流血，流产，金，金属，白色，右面，风狂，风等。",
    "玄武：江河湖泊，水流，长江，厕所，卫生间，水灾，雨，湿，水，水电，行船，运输水业，人的神态，睡觉，懒动，贪睡，神思昏沉，阴，阴暗，阴私，黑暗，不光明，不公正，骗子，欺骗，诈骗，假货，歪门邪道，暗算，失踪，走失，遗忘，偷，偷东西，流氓，匪徒，抢劫，失物，捕盗，聪明，多智，计谋，心里暗算，忧郁，忧闷，阴沉,情欲，色欲，风流好色，性关系，小姐，妓女，脏，不干净，垃圾，污水，后面，后方等。"
]


/******************************************六亲纳音*************************************** */
const sixQinNaYin = [
    "兄弟：代表兄弟、姐妹、朋友、同事、阻隔、竞争、破财、破耗、风云、门户、厕所、墙壁、贪财、赌博、抢劫、争夺、手臂、胳膊、腿、脚、牙、胃、肩、膀胱、饮食不纳、消化不良等。一切同类之人皆为兄弟，占财物以此有劫财之神，占谋事以此为阻隔之神。占表兄弟、占不亲近之同事、邻居不以兄弟爻为用神，而以应为用神。",
    "子孙：代表儿女、子孙、孩子、婴儿、晚辈、后代、侄女、侄儿、外甥、良将、僧道、出家人、教徒、士兵、公安、福神、财源、道路、走廊、动物、日、月、星、辰、晴天、饮酒、快乐、娱乐、无忧无虑、医生、营养、药品、乳房、五官、小便、咒符、气功师、巫婆、神汉、食道、呼吸道、气管、眼、耳、口、鼻、血管、毛孔、肠、生殖器、骨髓等。子孙为福德之神，为制鬼之神，为解忧之神，又为剥官引职之神。故谓之子孙乃是福神，诸事见之为喜，独占功名者忌之。",
    "妻财：代表妻子、爱人、女性、恋爱对象、女友、奴仆、保姆、佣人、随从、雇员、财产、资金、经济、价格、钱币、器物、仓库、粮食、灶、厨房、植物、货物、嫁妆、俸禄、工资、收入、报酬、费用、道理、脏物、装载物品、珠宝、首饰、日用品、晴天、毛发、饮食、血液、呼吸、眼泪、屎尿、汗水、乳汁、鼻涕、津液、腰、肛门等。",
    "官鬼：代表丈夫、男人、功名、名次、名字、官府、公安、官司、公家、司法部门、上级领导、雷电、雾、烟、鬼神、盗贼、坏人、逃犯、乱党、灾祸、忧愁、官位、工作、升学、职业、主人、疾病、尸体、死者、病灶、病毒、杂念，烦恼等。一切拘束我身者是也。",
    "父母：代表父母、爷爷、奶奶、姥姥、姥爷、姑妈、姑夫、姨妈、姨夫、舅妈、舅舅、老师、义父、义母、岳父、岳母、长辈、老人、天地、土地、坟墓、城池、围墙、房舍、建筑、工程、自行车、汽车、火车、船、飞机等交通工具，雨、雪、雨衣、雨伞、衣服、鞋帽、布匹、头巾、口罩、报告、文章、文件、书籍、报纸、信件、合同、信息、消息、信号、学校、医院、头、面部、胸、背、腹、臀部、病房、被褥、床单、工作单位、衙门等。在人通变，一切庇祐我身者为父母。"
]

/******************************************天干纳音*************************************** */
const ganZhiNaYin = [
    "甲子乙丑海中金：石油、珍珠、海矿、金库、海底沉船等。",
    "丙寅丁卯炉中火：煤炉、厨房、灶台、柴草、炼钢炉、枯死植物、饭馆、火锅等。",
    "戊辰己巳大林木：森林、山野、树木、花草、电线杆、木材批发部、林场、花园等。",
    "庚午辛未路旁土：道路、马路、清洁工、建筑工、干土、土堆、建筑工、垃圾堆等。",
    "壬申癸酉剑锋金：宝剑、凶器、兵器、椎盘、古董店、军队、晨练者、武术家等。",
    "甲戌乙亥山头火：夕阳、热气、烽火台、火山、霓虹灯、信息战、发电厂、机房等。",
    "丙子丁丑涧下水：云、自来水、灯油、喷泉、酒店、池塘、山涧、水源、水厂等。",
    "戊寅己卯城头土：城郭、山岳、城墙、住宅、高楼大厦、八达岭、长城、碉堡等。",
    "庚辰辛巳白腊金：蜡、玉、宝石、矿石、首饰、护肤品、化妆品、熔化等。",
    "壬午癸未杨柳木：杨柳、柔木、花草、灌木丛、花柳巷、牙签、公园、无立场等。",
    "甲申乙酉泉中水：水井、溪沟、山泉、喷泉、矿泉水、油井、矿井、泉州、湿润等。",
    "丙戌丁亥屋上土：瓦片、飞贼、墙壁、房子、砖瓦、烂尾楼、坟墓、装修业等。",
    "戊子己丑霹雳火：雷、烟火、闪电、电焊、火车、火箭、闪电、发电厂、变压器、高压线等。",
    "庚寅辛卯松柏木：松树、柏树、电杆、铁塔、烈士陵园、不朽、刚直、纪念碑、栋梁之才等。",
    "壬辰癸巳长流水：河流、溪水、水沟、工厂流水线、口水等。",
    "甲午乙未沙中金：钻石、纯金、合金、小首饰、沙漠、金属、人才等。",
    "丙申丁酉山下火：野火、路灯、萤火、香火、土窑、砖瓦窑、热电厂、炉灶等。",
    "戊戌己亥平地木：栋梁、树木、建材、枕木、木桥等。",
    "庚子辛丑壁上土：屋宇、洞壁、墙壁、挂历、飞贼、招牌、玻璃窗、涂料等。",
    "壬寅癸卯金箔金：金饰、描金、镀金、首饰、纸钱、表面风光等。",
    "甲辰乙巳覆灯火：灯烛、灯光、电筒、佛堂、寺庙、路灯、电筒等。",
    "丙午丁未天河水：月轮、雨、水光、瀑布、水塔、牛郎织女等。",
    "戊申己酉大驿土：稻田、大路、坦途、空旷之地、高速公路、操场、国道等。",
    "庚戌辛亥钗钏金：钗钏、首饰、珠宝、文物、古董、钟鼎、首饰加工店等。",
    "壬子癸丑桑柘木：湿木、树木、假山、养蚕业、丝绸、高档面料，故乡（桑梓地）等。",
    "甲寅乙卯大溪水：雨水、河流、露珠、洪水、大江、郊游、水运、淋浴等。",
    "丙辰丁巳沙中土：河谷、平原、湿泥、沙浴、紫砂壶、沙漠、堤岸、海滩等。",
    "戊午己未天上火：太阳、月亮、桂花、闪电、空难、流星、陨石、火箭等。",
    "庚申辛酉石榴木：石榴、结石、牙齿、水果店、肿瘤、青春痘、卵子等。",
    "壬戌癸亥大海水：海洋、浊水、渊海、清水、远洋轮、海量、上海、百川、出海口等。"
]
/******************************************十二长生*************************************** */
const yunNaYin = [
    "长生：含有出生，生长，来源，起点，帮助，依靠，哺育，源泉，根子，原始，苏醒，获救，救助，产生，寻找，得到，发生，吃饭的意思。",
    "沐浴：含有洗澡，入水，裸体，淫乱，淫秽，脱衣，恩泽，好处，有利，暴露，光秃秃，光溜，享受，坦诚，大小便，睡觉，破败，难看，无耻，滋润，照顾，等意思。",
    "冠带：含有穿衣，整装，和衣，打扮，包装，装饰，衣服，升级，荣誉，带帽，入伍，遮盖，外表，高贵等意思。",
    "临官：含有公家的，官府，有病，灾祸，有男人在身边，离死不远，巴结当官的，阿谀奉承，出仕，当官，有官运，有地位，公务员等意思。",
    "帝旺：含有荣发，发达，得意，精神，兴奋，神气，有力，雄壮，高大，擅长，强大，辉煌，欣欣向荣，腾达，有权，极限，高潮，顶点等意思。",
    "衰：含有无力，软弱，衰弱，弱小，不景气，弱智，败落，力小，倒霉，退缩，没靠山，弱点，胆小，虚弱，矮小，无能，没本事，不学无术，高不成低不就，不敢反抗等意思。",
    "病：含有疾病，病灶，瘟神，讨厌，憎恨，仇人，仇视，不足之处，缺点，毛病，弱点，漏洞，把柄，要害，心病，腐败，问题等意思。",
    "死：含有死亡，转牛角尖，不灵活，不能变通，滞留，终结，完蛋，认死理，一条道走到黑，没有余地，不景气，无生气，无活力，呆板，笨拙，想不开，心胸狭隘，无退路，寂静，安静，可怕等意思。",
    "墓：含有包容，收藏，埋藏，关闭，收拾，存放，管理，属于，控制，操纵，指挥，管制，包含，囊括，陷阱，不自由，入迷，受管束，隐藏，保护，保卫，围栏，仓库，权限，昏迷，昏沉，糊涂，黑暗，不流畅，不畅通，结束，阻力，阻塞等意思。",
    "绝：含有无退路，危险，绝地，绝境，悬崖，分手，断绝，背水一战，失望，心灰意冷，死心，无可救药，无能为力，无情，冷酷，不通融，停止，消失，无影无踪，把事情做绝，把话说绝等意思。",
    "胎：含有怀胎，酝酿，初步打算，计划，形成，先天的，天生的，本性难移，初级，勾连，牵挂，操心，想法，幼稚，弱小，年龄小，起步等意思。",
    "养：含有出生，生长，寄托，收养，休养，疗养，休息，依靠，营养，滋养，过继，培养，养育，扶持，扶助，怀疑，不放心，不塌实，心虚等意思。"
]

/*****************************************六十四卦**************************************** */
const sixFourNaYin = [
    "第1卦，" +
    "乾为天（乾卦）自强不息，" +
    "上上卦，" +
    "象曰：困龙得水好运交，不由喜气上眉梢，一切谋望皆如意，向后时运渐渐高。这个卦是同卦（下乾上乾）相叠。象征天，喻龙（德才的君子），又象征纯粹的阳和健，表明兴盛强健。乾卦是根据万物变通的道理，以“元、亨、利、贞”为卦辞，示吉祥如意，教导人遵守天道的德行。",
    "第2卦，" +
    "坤为地（坤卦）厚德载物，" +
    "上上卦，" +
    "象曰：肥羊失群入山岗，饿虎逢之把口张，适口充肠心欢喜，卦若占之大吉昌。这个卦是同卦（下坤上坤）相叠，阴性。象征地（与乾卦相反），顺从天。承载万物，伸展无穷无尽。坤卦以雌马为象征，表明地道生育抚养万物，而又依天顺时，性情温顺。它以“先迷后得”证明“坤”顺从“乾”，依随“乾”，才能把握正确方向，遵循正道，获取吉利。",
    "第3卦，" +
    "水雷屯（屯卦）起始维艰，" +
    "下下卦，" +
    "象曰：风刮乱丝不见头，颠三倒四犯忧愁，慢从款来左顺遂，急促反惹不自由。这个卦是异卦（下震上坎）相叠，震为雷，喻动；坎为雨，喻险。雷雨交加，险象丛生，环境恶劣。“屯”原指植物萌生大地。万物始生，充满艰难险阻，然而顺时应运，必欣欣向荣。",
    "第4卦，" +
    "山水蒙（蒙卦）启蒙奋发，" +
    "中下卦，" +
    "象曰：卦中爻象犯小耗，君子占之运不高，婚姻合伙有琐碎，做事必然受苦劳。这个卦是异卦（下坎上艮）相叠，艮是山的形象，喻止；坎是水的形象，喻险。卦形为山下有险，仍不停止前进，是为蒙昧，故称蒙卦。但因把握时机，行动切合时宜，因此，具有启蒙和通达的卦象。",
    "第5卦，" +
    "水天需（需卦）守正待机，" +
    "中上卦，" +
    "象曰：明珠土埋日久深，无光无亮到如今，忽然大风吹土去，自然显露有重新。这个卦是异卦（下乾上坎）相叠，下卦是乾，刚健之意；上卦是坎，险陷之意。以刚逢险，宜稳健之妥，不可冒失行动，观时待变，所往一定成功。",
    "第6卦，" +
    "天水讼（讼卦）慎争戒讼，" +
    "中下卦，" +
    "象曰：心中有事事难做，恰是二人争路走，雨下俱是要占先，谁肯让谁走一步。这个卦是异卦（下坎上乾）相叠。同需卦相反，互为“综卦”。乾为刚健，坎为险陷。刚与险，健与险，彼此反对，定生争讼。争讼非善事，务必慎重戒惧。",
    "第7卦，" +
    "地水师（师卦）行险而顺，" +
    "中上卦，" +
    "象曰：将帅领旨去出征，骑着烈马拉硬弓，百步穿杨去得准，箭中金钱喜气生。这个卦是异卦（下坎上坤）相叠。“师”指军队。坎为水、为险；坤为地、为顺，喻寓兵于农。兵凶战危，用兵乃圣人不得已而为之，但它可以顺利无阻碍地解决矛盾，因为顺乎形势，师出有名，故能化凶为吉。",
    "第8卦，" +
    "水地比（比卦）诚信团结，" +
    "上上卦，" +
    "象曰：顺风行船撒起帆，上天又助一蓬风，不用费力逍遥去，任意而行大亨通。这个卦是异卦（下坤上坎）相叠，坤为地；坎为水。水附大地，地纳河海，相互依赖，亲密无间。此卦与师卦完全相反，互为综卦。它阐述的是相亲相辅，宽宏无私，精诚团结的道理。",
    "第9卦，" +
    "风天小畜（小畜卦）蓄养待进，" +
    "下下卦，" +
    "象曰：苗逢旱天尽焦梢，水想云浓雨不浇，农人仰面长吁气，是从款来莫心高。这个卦是异卦（下乾上巽）相叠，乾为天；巽为风。喻风调雨顺，谷物滋长，故卦名小畜（蓄）。力量有限，须待发展到一定程度，才可大有作为。",
    "第10卦，" +
    "天泽履（履卦）脚踏实地，" +
    "中上卦，" +
    "象曰：凤凰落在西岐山，长鸣几声出圣贤，天降文王开基业，富贵荣华八百年。这个卦是异卦（下兑上乾）相叠，乾为天；兑为泽，以天喻君，以泽喻民，原文：“履（踩）虎尾、不咥（咬）人。”因此，结果吉利。君上民下，各得其位。兑柔遇乾刚，所履危。履意为实践，卦义是脚踏实地的向前进取的意思。",
    "第11卦，" +
    "地天泰（泰卦）应时而变，" +
    "中中卦，" +
    "象曰：学文满腹入场闱，三元及第得意回，从今解去愁和闷，喜庆平地一声雷。这个卦是异卦（下乾上坤）相叠，乾为天，为阳；坤为地，为阴，阴阳交感，上下互通，天地相交，万物纷纭。反之则凶。万事万物，皆对立，转化，盛极必衰，衰而转盛，故应时而变者泰（通）。",
    "第12卦，" +
    "天地否(pǐ)（否卦）不交不通，" +
    "中中卦，" +
    "象曰：虎落陷坑不堪言，进前容易退后难，谋望不遂自己便，疾病口舌事牵连。这个卦是异卦（下坤上乾）相叠，其结构同泰卦相反，系阳气上升，阴气下降，天地不交，万物不通。它们彼此为“综卦”，表明泰极而否，否极泰来，互为因果。",
    "第13卦，" +
    "天火同人（同人卦）上下和同，" +
    "中上卦，" +
    "象曰：心中有事犯猜疑，谋望从前不着实，幸遇明人来指引，诸般忧闷自消之。这个卦是异卦（下离上乾）相叠，乾为天，为君；离为火，为臣民百姓，上天下火，火性上升，同于天，上下和同，同舟共济，人际关系和谐，天下大同。",
    "第14卦，" +
    "火天大有（大有卦）顺天依时，" +
    "上上卦，" +
    "象曰：砍树摸雀作事牢，是非口舌自然消，婚姻合伙不费力，若问走失未逃脱。这个卦是异卦（下乾上离）相叠。上卦为离，为火；下卦为乾，为天。火在天上，普照万物，万民归顺，顺天依时，大有所成。",
    "第15卦，" +
    "地山谦（谦卦）内高外低，" +
    "中中卦，" +
    "象曰：天赐贫人一封金，不争不抢两平分，彼此分得金到手，一切谋望皆遂心。这个卦是异卦（下艮上坤）相叠，艮为山，坤为地。地面有山，地卑（低）而山高，是为内高外低，比喻功高不自居，名高不自誉，位高不自傲。这就是谦。",
    "第16卦，" +
    "雷地豫（豫卦）顺时依势，" +
    "中中卦，" +
    "象曰：太公插下杏黄旗，收妖为徒归西岐，自此青龙得了位，一旦谋望百事宜。这个卦是异卦（下坤上震）相叠，坤为地，为顺；震为雷，为动。雷依时出，预示大地回春。因顺而动，和乐之源。此卦与谦卦互为综卦，交互作用。",
    "第17卦，" +
    "泽雷随（随卦）随时变通，" +
    "中中卦，" +
    "象曰：泥里步踏这几年，推车靠崖在眼前，目下就该再使力，扒上崖去发财源。这个卦是异卦（下震上兑）相叠，震为雷、为动；兑为悦。动而悦就是“随”。随指相互顺从，己有随物，物能随己，彼此沟通。随必依时顺势，有原则和条件，以坚贞为前提。",
    "第18卦，" +
    "山风蛊（蛊卦）振疲起衰，" +
    "中中卦，" +
    "象曰：卦中爻象如推磨，顺当为福反为祸，心中有益且迟迟，凡事尽从忙处错。这个卦是异卦（下巽上艮）相叠，与随卦互为综卦。蛊（gu）本意为事，引申为多事、混乱。器皿久不用而生虫称“蛊”，喻天下久安而因循、腐败，必须革新创造，治理整顿，挽救危机，重振事业。",
    "第19卦，" +
    "地泽临（临卦）教民保民，" +
    "中上卦，" +
    "象曰：君王无道民倒悬，常想拨云见青天，幸逢明主施仁政，重又安居乐自然。这个卦是异卦（下兑上坤）相叠。坤为地；兑为泽，地高于泽，泽容于地。喻君主亲临天下，治国安邦，上下融洽。",
    "第20卦，" +
    "风地观（观卦）观下瞻上，" +
    "中上卦，" +
    "象曰：卦遇蓬花旱逢河，生意买卖利息多，婚姻自有人来助，出门永不受折磨。这个卦是异卦（下坤上巽）相叠，风行地上，喻德教遍施。观卦与临卦互为综卦，交相使用。在上者以道义观天下；在下者以敬仰瞻上，人心顺服归从。",
    "第21卦，" +
    "火雷噬嗑（噬嗑卦）刚柔相济，" +
    "上上卦，" +
    "象曰：运拙如同身受饥，幸得送饭又送食，适口充腹心欢喜，忧愁从此渐消移。这个卦是异卦（下震上离）相叠。离为阴卦；震为阳卦。阴阳相交，咬碎硬物，喻恩威并施，宽严结合，刚柔相济。噬嗑（shihe）为上下颚咬合，咀嚼。",
    "第22卦，" +
    "山火贲（贲卦）饰外扬质，" +
    "中上卦，" +
    "象曰：近来运转瑞气周，窈窕淑女君子求。钟鼓乐之大吉庆，占者逢之喜临头。这个卦是异卦（下离上艮）相叠。离为火为明；艮为山为止。文明而有节制。贲（bi）卦论述文与质的关系，以质为主，以文调节。贲，文饰、修饰。",
    "第23卦，" +
    "山地剥（剥卦）顺势而止，" +
    "中下卦，" +
    "象曰：鹊遇天晚宿林中，不知林内先有鹰，虽然同处心生恶，卦若逢之是非轻。这个卦是异卦（下坤上艮）相叠。五阴在下，一阳在上，阴盛而阳孤；高山附于地。二者都是剥落象，故为“剥卦”。此卦阴盛阳衰，喻小人得势，君子困顿，事业败坏。",
    "第24卦，" +
    "地雷复（复卦）寓动于顺，" +
    "中中卦，" +
    "象曰：马氏太公不相合，世人占之忧疑多，恩人无义反为怨，是非平地起风波。这个卦是异卦（下震上坤）相叠。震为雷、为动；坤为地、为顺，动则顺，顺其自然。动在顺中，内阳外阴，循序运动，进退自如，利于前进。",
    "第25卦，" +
    "天雷无妄（无妄卦）无妄而得，" +
    "下下卦，" +
    "象曰：飞鸟失机落笼中，纵然奋飞不能腾，目下只宜守本分，妄想扒高万不能。这个卦是异卦（下震上乾）相叠。乾为天为刚为健；震为雷为刚为动。动而健，刚阳盛，人心振奋，必有所得，但唯循纯正，不可妄行。无妄必有获，必可致福。",
    "第26卦，" +
    "山天大畜（大畜卦）止而不止，" +
    "中上卦，" +
    "象曰：忧愁常锁两眉头，千头万绪挂心间，从今以后防开阵，任意行而不相干。这个卦是异卦（下乾上艮）相叠。乾为天，刚健；艮为山，笃实。畜者积聚，大畜意为大积蓄。为此不畏严重的艰难险阻，努力修身养性以丰富德业。",
    "第27卦，" +
    "山雷颐（颐卦）纯正以养，" +
    "上上卦，" +
    "象曰：太公独钓渭水河，手执丝杆忧愁多，时来又遇文王访，自此永不受折磨。这个卦是异卦（下震上艮）相叠。震为雷，艮为山。山在上而雷在下，外实内虚。春暖万物养育，依时养贤育民。阳实阴虚，实者养人，虚者为人养。自食其力。",
    "第28卦，" +
    "泽风大过（大过卦）非常行动，" +
    "中下卦，" +
    "象曰：夜晚梦里梦金银，醒来仍不见一文，目下只宜求本分，思想络是空劳神。这个卦是异卦（下巽上兑）相叠。兑为泽、为悦，巽为木、为顺，泽水淹舟，遂成大错。阴阳爻相反，阳大阴小，行动非常，有过度形象，内刚外柔。",
    "第29卦，" +
    "坎为水（坎卦）行险用险，" +
    "下下卦，" +
    "象曰：一轮明月照水中，只见影儿不见踪，愚夫当财下去取，摸来摸去一场空。这个卦是同卦（下坎上坎）相叠。坎为水、为险，两坎相重，险上加险，险阻重重。一阳陷二阴。所幸阴虚阳实，诚信可豁然贯通。虽险难重重，却方能显人性光彩。",
    "第30卦，" +
    "离为火（离卦）附和依托，" +
    "中上卦，" +
    "象曰：官人来占主高升，庄农人家产业增，生意买卖利息厚，匠艺占之大亨通。这个卦是同卦（下离上离）相叠。离者丽也，附着之意，一阴附丽，上下二阳，该卦象征火，内空外明。离为火、为明、太阳反复升落，运行不息，柔顺为心。",
    "第31卦，" +
    "泽山咸（咸卦）相互感应，" +
    "中上卦，" +
    "象曰：运去黄金失色，时来棒槌发芽，月令极好无差，且喜心宽意大。这个卦是异卦（下艮上兑）相叠。艮为山；泽为水。兑柔在上，艮刚在下，水向下渗，柔上而刚下，交相感应。感则成。",
    "第32卦，" +
    "雷风恒（恒卦）恒心有成，" +
    "中上卦，" +
    "象曰：渔翁寻鱼运气好，鱼来撞网跑不了，别人使本挣不来，谁想一到就凑合。这个卦是异卦（下巽上震）相叠。震为男、为雷；巽为女、为风。震刚在上，巽柔在下。刚上柔下，造化有常，相互助长。阴阳相应，常情，故称为恒。",
    "第33卦，" +
    "天山遁（遁卦）遁世救世，" +
    "下下卦，" +
    "象曰：浓云蔽日不光明，劝君且莫出远行，婚姻求财皆不利，提防口舌到门庭。这个卦是异卦（下艮上乾）相叠。乾为天，艮为山。天下有山，山高天退。阴长阳消，小人得势，君子退隐，明哲保身，伺机救天下。",
    "第34卦，" +
    "雷天大壮（大壮卦）壮勿妄动，" +
    "中上卦，" +
    "象曰：卦占工师得大木，眼前该着走上路，时来运转多顺当，有事自管放心宽。这个卦是异卦（下乾上震）相叠。震为雷；乾为天。乾刚震动。天鸣雷，云雷滚，声势宏大，阳气盛壮，万物生长。刚壮有力故曰壮。大而且壮，故名大壮。四阳壮盛，积极而有所作为，上正下正，标正影直。",
    "第35卦，" +
    "火地晋（晋卦）求进发展，" +
    "中上卦，" +
    "象曰：锄地锄去苗里草，谁想财帛将人找，一锄锄出银子来，这个运气也算好。这个卦是异卦（下坤上离）相叠。离为日，为光明；坤为地。太阳高悬，普照大地，大地卑顺，万物生长，光明磊落，柔进上行，喻事业蒸蒸日上。",
    "第36卦，" +
    "地火明夷（明夷卦）晦而转明，" +
    "中下卦，" +
    "象曰：时乖运拙走不着，急忙过河拆了桥，恩人无义反为怨，凡事无功枉受劳。这个卦是异卦（下离上坤）相叠。离为明，坤为顺；离为日；坤为地。日没入地，光明受损，前途不明，环境困难，宜遵时养晦，坚守正道，外愚内慧，韬光养晦。",
    "第37卦，" +
    "风火家人（家人卦）诚威治业，" +
    "下下卦，" +
    "象曰：一朵鲜花镜中开，看着极好取不来，劝君休把镜花恋，卦若逢之主可怪。这个卦是异卦（下离上巽）相叠。离为火；巽为风。火使热气上升，成为风。一切事物皆应以内在为本，然后伸延到外。发生于内，形成于外。喻先治家而后治天下，家道正，天下安乐。",
    "第38卦，" +
    "火泽睽（睽卦）异中求同，" +
    "下下卦，" +
    "象曰：此卦占来运气歹，如同太公作买卖，贩猪牛快贩羊迟，猪羊齐贩断了宰。这个卦是异卦（下兑上离）相叠。离为火；兑为泽。上火下泽，相违不相济。克则生，往复无空。万物有所不同，必有所异，相互矛盾。睽即矛盾。",
    "第39卦，" +
    "水山蹇（蹇卦）险阻在前，" +
    "下下卦，" +
    "象曰：大雨倾地雪满天，路上行人苦又寒，拖泥带水费尽力，事不遂心且耐烦。这个卦是异卦（下艮上坎）相叠。坎为水；艮为山。山高水深，困难重重，人生险阻，见险而止，明哲保身，可谓智慧。蹇，跋行艰难。",
    "第40卦，" +
    "雷水解（解卦）柔道致治，" +
    "中上卦，" +
    "象曰：目下月令如过关，千辛万苦受熬煎，时来恰相有人救，任意所为不相干。这个卦是异卦（下坎上震）相叠。震为雷、为动；坎为水、为险。险在内，动在外。严冬天地闭塞，静极而动。万象更新，冬去春来，一切消除，是为解。",
    "第41卦，" +
    "山泽损（损卦）损益制衡，" +
    "下下卦，" +
    "象曰：时运不至费心多，比作推车受折磨，山路崎岖吊下耳，左插右按按不着。这个卦是异卦（下兑上艮）相叠。艮为山；兑为泽。上山下泽，大泽浸蚀山根。损益相间，损中有益，益中有损。二者之间，不可不慎重对待。损下益上，治理国家，过度会损伤国基。应损则损，但必量力、适度。少损而益最佳。",
    "第42卦，" +
    "风雷益（益卦）损上益下，" +
    "上上卦，" +
    "象曰：时来运转吉气发，多年枯木又开花，枝叶重生多茂盛，几人见了几人夸。这个卦是异卦（下震上巽）相叠。巽为风；震为雷。风雷激荡，其势愈强，雷愈响，风雷相助互长，交相助益。此卦与损卦相反。它是损上以益下，后者是损下以益上。二卦阐述的是损益的原则。",
    "第43卦，" +
    "泽天夬（夬卦）决而能和，" +
    "上上卦，" +
    "象曰：蜘蛛脱网赛天军，粘住游蜂翅翎毛，幸有大风吹破网，脱离灾难又逍遥。这个卦是异卦（下乾上兑）相叠。乾为天为健；兑为泽为悦。泽气上升，决注成雨，雨施大地，滋润万物。五阳去一阴，去之不难，决（去之意）即可，故名为夬（guài），夬即决。",
    "第44卦，" +
    "天风姤（姤卦）天下有风，" +
    "上卦，" +
    "象曰：他乡遇友喜气欢，须知运气福重添，自今交了顺当运，向后管保不相干。这个卦是异卦（下巽上乾）相叠。乾为天；巽为风。天下有风，吹遍大地，阴阳交合，万物茂盛。姤（gǒu）卦与夬卦相反，互为”综卦”。姤即遘，阴阳相遇。但五阳一阴，不能长久相处。",
    "第45卦，" +
    "泽地萃（萃卦）荟萃聚集，" +
    "中上卦，" +
    "象曰：游鱼戏水被网惊，跳过龙门身化龙，三尺杨柳垂金线，万朵桃花显你能。这个卦是异卦相叠（下坤上兑）。坤为地、为顺；兑为泽、为水。泽泛滥淹没大地，人众多相互斗争，危机必四伏，务必顺天任贤，未雨绸缪，柔顺而又和悦，彼此相得益彰，安居乐业。萃，聚集、团结。",
    "第46卦，" +
    "地风升（升卦）柔顺谦虚，" +
    "上上卦，" +
    "象曰：士人来占必得名，生意买卖也兴隆，匠艺逢之交易好，农间庄稼亦收成。这个卦是异卦相叠（下巽上坤）。坤为地、为顺；巽为木、为逊。大地生长树木，逐步的成长，日渐高大成材，喻事业步步高升，前程远大，故名“升”。",
    "第47卦，" +
    "泽水困（困卦）困境求通，" +
    "中上卦，" +
    "象曰：时运不来好伤怀，撮上押去把梯抬，一筒虫翼无到手，转了上去下不来。这个卦是异卦（下坎上兑）相叠。兑为阴为泽喻悦；坎为阳为水喻险。泽水困，陷入困境，才智难以施展，仍坚守正道，自得其乐，必可成事，摆脱困境。",
    "第48卦，" +
    "水风井（井卦）求贤若渴，" +
    "上上卦，" +
    "象曰：枯井破费已多年，一朝流泉出来鲜，资生济渴人称羡，时来运转喜自然。这个卦是异卦（下巽上坎）相叠。坎为水；巽为木。树木得水而蓬勃生长。人靠水井生活，水井由人挖掘而成。相互为养，井以水养人，经久不竭，人应取此德而勤劳自勉。",
    "第49卦，" +
    "泽火革（革卦）顺天应人，" +
    "上上卦，" +
    "象曰：苗逢旱天渐渐衰，幸得天恩降雨来，忧去喜来能变化，求谋干事遂心怀。这个卦是异卦（下离上兑）相叠。离为火；兑为泽，泽内有水。水在上而下浇，火在下而上升。火旺水干；水大火熄。二者相生亦相克，必然出现变革。变革是宇宙的基本规律。",
    "第50卦，" +
    "火风鼎（鼎卦）稳重图变，" +
    "中下卦，" +
    "象曰：莺鹜蛤蜊落沙滩，蛤蜊莺鹜两翅扇，渔人进前双得利，失走行人却自在。这个卦是异卦（下巽上离）相叠。燃木煮食，化生为熟，除旧布新的意思。鼎为重宝大器，三足稳重之象。煮食，喻食物充足，不再有困难和困扰。在此基础上宜变革，发展事业。",
    "第51卦，" +
    "震为雷（震卦）临危不乱，" +
    "中上卦，" +
    "象曰：一口金钟在淤泥，人人拿着当玩石，忽然一日钟悬起，响亮一声天下知。这个卦是同卦（下震上震）相叠。震为雷，两震相叠，反响巨大，可消除沉闷之气，亨通畅达。平日应居安思危，怀恐惧心理，不敢有所怠慢，遇到突发事变，也能安然自若，谈笑如常。",
    "第52卦，" +
    "艮为山（艮卦）动静适时，" +
    "中下卦，" +
    "象曰：财帛常打心头走，可惜眼前难到手，不如意时且忍耐，逢着闲事休开口。这个卦是同卦（下艮上艮）相叠。艮为山，二山相重，喻静止。它和震卦相反。高潮过后，必然出现低潮，进入事物的相对静止阶段。静止如山，宜止则止，宜行则行。行止即动和静，都不可失机，应恰到好处，动静得宜，适可而止。",
    "第53卦，" +
    "风山渐（渐卦）渐进蓄德，" +
    "上上卦，" +
    "象曰：俊鸟幸得出笼中，脱离灾难显威风，一朝得意福力至，东西南北任意行。这个卦是异卦（下艮上巽）相叠。艮为山；巽为木。山上有木，逐渐成长，山也随着增高。这是逐渐进步的过程，所以称渐，渐即进，渐渐前进而不急速。",
    "第54卦，" +
    "雷泽归妹（归妹卦）立家兴业，" +
    "下下卦，" +
    "象曰：求鱼须当向水中，树上求之不顺情，受尽爬揭难随意，劳而无功运平平。这个卦是异卦（下兑上震）相叠。震为动、为长男；兑为悦、为少女。以少女从长男，产生爱慕之情，有婚姻之动，有嫁女之象，故称归妹。男婚女嫁，天地大义，人的开始和终结。上卦与渐卦为综卦，交互为用。",
    "第55卦，" +
    "雷火丰（丰卦）日中则斜，" +
    "上上卦，" +
    "象曰：古镜昏暗好几年，一朝磨明似月圆，君子谋事逢此卦，时来运转喜自然。这个卦是异卦（下离上震）相叠，电闪雷鸣，成就巨大，喻达到顶峰，如日中天。告诫；务必注意事物向相反方面发展。治乱相因，盛衰无常，不可不警惕。",
    "第56卦，" +
    "火山旅（旅卦）依义顺时，" +
    "下下卦，" +
    "象曰：飞鸟树上垒窝巢，小人使计举火烧，君占此卦为不吉，一切谋望枉徒劳。这个卦是异卦（下艮上离）相叠。此卦与丰卦相反，互为“综卦”。山中燃火，烧而不止，火势不停地向前蔓延，如同途中行人，急于赶路。因而称旅卦。",
    "第57卦，" +
    "巽为风（巽卦）谦逊受益，" +
    "中上卦，" +
    "象曰：一叶孤舟落沙滩，有篙无水进退难，时逢大雨江湖溢，不用费力任往返。这个卦是同卦（下巽上巽）相叠，巽（xùn）为风，两风相重，长风不绝，无孔不入，巽义为顺。谦逊的态度和行为可无往不利。",
    "第58卦，" +
    "兑为泽（泽卦）刚内柔外，" +
    "上上卦，" +
    "象曰：这个卦象真可取，觉着做事不费力，休要错过这机关，事事觉得随心意。这个卦是同卦（下泽上泽）相叠。泽为水。两泽相连，两水交流，上下相和，团结一致，朋友相助，欢欣喜悦。兑为悦也。同秉刚健之德，外抱柔和之姿，坚行正道，导民向上。",
    "第59卦，" +
    "风水涣（涣卦）拯救涣散，" +
    "下下卦，" +
    "象曰：隔河望见一锭金，欲取岸宽水又深，指望资财难到手，昼思夜想枉费心。这个卦是异卦（下坎上巽）相叠。风在水上行，推波助澜，四方流溢。涣，水流流散之意。象征组织和人心涣散，必用积极的手段和方法克服，战胜弊端，挽救涣散，转危为安。",
    "第60卦，" +
    "水泽节（节卦）万物有节，" +
    "上上卦，" +
    "象曰：时来运转喜气生，登台封神姜太公，到此诸神皆退位，纵然有祸不成凶。这个卦是异卦（下兑上坎）相叠。兑为泽；坎为水。泽有水而流有限，多必溢于泽外。因此要有节度，故称节。节卦与涣卦相反，互为综卦，交相使用。天地有节度才能常新，国家有节度才能安稳，个人有节度才能完美。",
    "第61卦，" +
    "风泽中孚（中孚卦）诚信立身，" +
    "下下卦，" +
    "象曰：路上行人色匆匆，急忙无桥过薄冰，小心谨慎过得去，一步错了落水中。这个卦是异卦（下兑上巽）相叠。孚（fú）本义孵，孵卵出壳的日期非常准确，有信的意义。卦形外实内虚，喻心中诚信，所以称中孚卦。这是立身处世的根本。",
    "第62卦，" +
    "雷山小过（小过卦）行动有度，" +
    "中上卦，" +
    "象曰：行人路过独木桥，心内惶恐眼里瞧，爽利保你过得去，慢行一定不安牢。这个卦是异卦（下艮上震）相叠。艮为山；震为雷。过山雷鸣，不可不畏惧。阳为大，阴为小，卦外四阴超过中二阳，故称“小过”，小有越过。",
    "第63卦，" +
    "水火既济（既济卦）盛极将衰，" +
    "中上卦，" +
    "象曰：金榜以上题姓名，不负当年苦用功，人逢此卦名吉庆，一切谋望大亨通。这个卦是异卦（下离上坎）相叠。坎为水；离为火。水火相交，水在火上，水势压倒火势，救火大功告成。既，已经；济，成也。既济就是事情已经成功，但终将发生变故。",
    "第64卦，" +
    "火水未济（未济卦）事业未竟，" +
    "中下卦，" +
    "象曰：离地着人几丈深，是防偷营劫寨人，后封太岁为凶煞，时加谨慎祸不侵。这个卦是异卦（下坎上离）相叠。离为火；坎为水。火上水下，火势压倒水势，救火大功未成，故称未济。《周易》以乾坤二卦为始，以既济、未济二卦为终，充分反映了变化发展的思想。",
]


var n = baGuaArr.length;
let sixFourList = new Array(n).fill([])

Page({
    data: {
        //当前时间
        solarTime: '',
        //当前星期
        week: '',
        //四柱
        yearL: '',
        monthL: '',
        dayL: '',
        hourL: '',
        //旬空
        emptyL: '',
        //当前农历日期
        lunarDate: '',
        //六神
        sixGodList: [],
        //本卦名称
        ownGua: '',
        //本卦宫位
        ownGuaP: '',
        //本卦身
        ownGuaBody: '',
        //变卦名称
        changeGua: '',
        //变卦宫位
        changeGuaP: '',
        //变卦身
        changeGuaBody: '',
        //页面显示中文
        nameList: [],
        // input: '',
        name: '',
        changeMarkHide: true
        // saveHide: false,
        // addHide: true,
        // openId: ''
    },
    onShareAppMessage: function () {
        return {
            title: '分享六爻策给你的伙伴吧',
            path: '/pages/index/index',
            imageUrl: '/images/6YCSHARE.png'
        }
    },
    // getOpenId: function () {
    //     wx.cloud.callFunction({
    //         name: 'main',
    //         config: {
    //             env: envId
    //         },
    //         data: {
    //             type: 'getOpenId'
    //         }
    //     }).then((resp) => {
    //         console.log("OPEN_ID : " + resp.result.openid);
    //         this.setData({
    //             openId: resp.result.openid
    //         });

    //     }).catch((e) => {
    //         console.log(e);
    //     });
    // },
    autoStyle: function () {
        var systeminfo = wx.getSystemInfoSync();
        console.log(systeminfo);

        //px为单位
        var sW = systeminfo.screenWidth;
        var sH = systeminfo.screenHeight

        var rate = 750 / sW;
        console.log(rate);

        //rpx为单位
        var rW = parseInt(sW * rate)
        var rH = parseInt(sH * rate)

        //距离左边的宽度
        var timeML = rH * 0.14

        //字体大小
        var fontS = 1

        //屏幕长宽比,适应pad
        var hwNum = sW / sH

        console.log(hwNum);
        if (hwNum < 1.6) {
            timeML = rH * 0.01
            fontS = 0.75
        }

        //time的高度
        var timeH = rH * 0.155

        //time内部元素的文字大小
        var timeS = rH * 0.035 * fontS

        //solarH
        var solarH = rH * 0.035

        //lunarH
        var lunarH = rH * 0.035

        //神煞
        var xingShaH = rH * 0.07

        //上面高度
        var upH = rH * 0.035

        var pageT = rH * 0.13

        //pageH
        var pageH = rH * 0.3

        var pageS = rH * 0.035  * fontS

        //一行的高度
        var lineH = rH * 0.045

        //卦身的高度和字体大小
        var gbMT = rH * 0.01
        var gbH = rH * 0.045
        var gbS = rH * 0.045

        //设置按钮的高度和大小
        // var bH = parseInt(rH * 0.06)
        // var bW = parseInt(rW / 4)
        // var bSize = parseInt(rH * 0.05 * 0.5)
        // var inputH = bH - 7

        this.setData({
            timeML: timeML,
            timeH: timeH,
            timeS: timeS,
            solarH: solarH,
            lunarH: lunarH,
            xingShaH: xingShaH,
            upH: upH,
            pageT: pageT,
            pageH: pageH,
            pageS: pageS,
            lineH: lineH,
            gbMT: gbMT,
            gbH: gbH,
            gbS: gbS,
            // inputH : inputH,
            // bH: bH,
            // bW: bW,
            // bSize: bSize
        })
    },
    onLoad: function () {
        //自适应高度
        this.autoStyle()

        //自定义弹窗
        this.dialog = this.selectComponent(".mydialog");

        var start = new Date().getTime();

        //获取全局变量
        var yaoList = app.globalData.yaoList
        var nowDate = app.globalData.nowDate
        var longitude = app.globalData.longitude


        log.info('pan-onShow-option-这里是打印全局变量yaoList', yaoList)
        log.info('pan-onShow-option-这里是打印全局变量nowDate', nowDate)
        log.info('pan-onShow-option-这里是打印全局变量longitude', longitude)
        log.addFilterMsg('panOnShowOption')

        /***上述是已经把时间确定好了 */
        this.getAllData(yaoList, nowDate, longitude)

        var end = new Date().getTime();
        console.log("使用时间###############" + (end - start));

    },
    diytoast: function (text) {
        this.dialog.show(text);
    },
    getAllData(yaoList, nowDate, longitude) {

        //获取当前四柱
        var ob = sizhu.getSiZhu(nowDate, longitude)

        log.info('hor-getAllData-四柱和真太阳', ob)
        log.addFilterMsg('horSiZhu')
        console.log("下面打印四柱和真太阳:")
        console.log(ob)

        //月建的index
        var yue = new Object()
        yue.gan = tgArr.indexOf(ob.bz_jy.substr(0, 1))
        yue.zhi = dzArr.indexOf(ob.bz_jy.substr(1, 1))
        console.log("yue ： ")
        console.log(yue);

        var ri = new Object()
        ri.gan = tgArr.indexOf(ob.bz_jr.substr(0, 1))
        ri.zhi = dzArr.indexOf(ob.bz_jr.substr(1, 1))
        console.log("ri ： ")
        console.log(ri);

        //获取旬空
        var empty = this.getEmpty(ob)
        console.log("旬空 ： " + empty)
        var emptyList = []
        emptyList[0] = dzArr.indexOf(emptyArr[empty].split(" ")[0])
        emptyList[1] = dzArr.indexOf(emptyArr[empty].split(" ")[1])
        console.log("emptyList ： ")
        console.log(emptyList);

        //获取神煞
        this.getShaList(ob)

        //获取六兽
        var sixGodList = this.getSixBeast(ob)
        console.log("六兽 ： ")
        console.log(sixGodList)
        //获取六十四卦
        var sixFourList = this.getSixFourGua()
        console.log("六十四卦 ： ")
        console.log(sixFourList)

        //获取当前本卦
        var yaoList = this.getOwnYaoList(yaoList)
        console.log("yaoList ： ")
        console.log(yaoList)
        //获取本卦爻象
        var yaoImageObj = this.getYaoImage(yaoList)
        console.log("yaoImageObj ： ")
        console.log(yaoImageObj)
        //获取本爻数字
        var yaoNumObj = this.getYaoNum(yaoList)
        console.log("yaoNumObj ： ")
        console.log(yaoNumObj)
        //获取本爻x、y
        var xyObj = this.getXYByNum(yaoNumObj.guaNum)
        console.log("xyObj ： ")
        console.log(xyObj)
        //本宫的x
        var x = xyObj.x
        //获取世应列表
        var shiYingList = this.getShiYingList(xyObj.y)
        console.log("shiYingList ： ")
        console.log(shiYingList)
        //获取卦身
        var guaBodyIndex = this.getGuaBody(yaoList, xyObj.y)
        console.log("guaBodyIndex ： ")
        console.log(guaBodyIndex)
        //获取纳甲
        var naJiaObj = this.getNaJiaObj(x, yaoNumObj.neiGua, yaoNumObj.waiGua)
        console.log("naJiaObj ： ")
        console.log(naJiaObj)
        //获取本宫纳甲
        var gongNaJiaObj = this.getNaJiaObj(x, x, x)
        console.log("gongNaJiaObj ： ")
        console.log(gongNaJiaObj)
        //获取伏神
        var fuShenObj = this.getFuShenList(gongNaJiaObj, naJiaObj)
        console.log("fuShenObj ： ")
        console.log(fuShenObj)
        //获取本宫爻list
        var gongYaoList = this.getGongYaoList(x, sixFourList)
        console.log("gongYaoList ： ")
        console.log(gongYaoList)
        //获取伏神的象
        var fuShenImageObj = this.getYaoImage(gongYaoList)
        console.log(fuShenImageObj);

        var allObj = new Object()
        allObj.yue = yue
        allObj.ri = ri
        allObj.emptyList = emptyList
        allObj.sixGodList = sixGodList
        allObj.sixQinList = naJiaObj.sixQinList
        allObj.ganList = naJiaObj.ganList
        allObj.zhiList = naJiaObj.zhiList
        allObj.wxList = naJiaObj.wxList
        allObj.yaoImageList = yaoImageObj.yaoImageList
        allObj.shiYingList = shiYingList
        allObj.changeList = yaoImageObj.changeList
        allObj.FsixQinList = fuShenObj.sixQinList
        allObj.FganList = fuShenObj.ganList
        allObj.FzhiList = fuShenObj.zhiList
        allObj.FwxList = fuShenObj.wxList
        allObj.FyaoImageList = fuShenImageObj.yaoImageList

        allObj.CsixQinList = []
        allObj.CganList = []
        allObj.CzhiList = []
        allObj.CwxList = []
        allObj.CyaoImageList = []
        allObj.CshiYingList = []

        if (yaoImageObj.isChangeFlag) {
            //获取变卦列表
            var changeYaoList = this.getChangeYaoList(yaoList)
            console.log("changeYaoList ： ")
            console.log(changeYaoList)
            //获取变卦爻象
            var changeImageObj = this.getYaoImage(changeYaoList)
            console.log("changeImageObj ： ")
            console.log(changeImageObj)
            //获取本爻数字
            var changeNumObj = this.getYaoNum(changeYaoList)
            console.log("changeNumObj ： ")
            console.log(changeNumObj)
            //获取本爻x、y
            var changeXyObj = this.getXYByNum(changeNumObj.guaNum)
            console.log("changeXyObj ： ")
            console.log(changeXyObj)
            //获取世应列表
            var changeShiYingList = this.getShiYingList(changeXyObj.y)
            console.log("changeShiYingList ： ")
            console.log(changeShiYingList)
            //获取卦身
            var changeGuaBodyIndex = this.getGuaBody(changeYaoList, changeXyObj.y)
            console.log("changeGuaBodyIndex ： ")
            console.log(changeGuaBodyIndex)
            //获取纳甲
            var changeNaJiaObj = this.getNaJiaObj(x, changeNumObj.neiGua, changeNumObj.waiGua)
            console.log("changeNaJiaObj ： ")
            console.log(changeNaJiaObj)

            allObj.CsixQinList = changeNaJiaObj.sixQinList
            allObj.CganList = changeNaJiaObj.ganList
            allObj.CzhiList = changeNaJiaObj.zhiList
            allObj.CwxList = changeNaJiaObj.wxList
            allObj.CyaoImageList = changeImageObj.yaoImageList
            allObj.CshiYingList = changeShiYingList
        }
        console.log("allObj ： ")
        console.log(allObj);

        /*********************获取所有标记的名称 *********************/
        this.getMarkList(allObj)

        /*********************获取所有list的名称 *********************/
        var allObjNameList = this.getListName(allObj)
        console.log(allObjNameList);

        //页面赋值
        this.setData({
            solarTime: util.formatTime(nowDate),
            week: util.getWeekByDate(nowDate),
            yearL: ob.bz_jn,
            monthL: ob.bz_jy,
            dayL: ob.bz_jr,
            hourL: ob.bz_js,
            emptyL: emptyArr[empty],
            lunarDate: ob.newmonth + '月' + ob.newday,
        })

        var ownGuaName = ''
        var changeGuaName = ''
        if (!yaoImageObj.isChangeFlag) {
            var guiYouStr = ''
            if (xyObj.y == 6) {
                guiYouStr = "(游魂)"
            } else if (xyObj.y == 7) {
                guiYouStr = "(归魂)"
            }
            ownGuaName = naJiaNameArr[xyObj.x][xyObj.y] + guiYouStr + "[" + baGuaArr[xyObj.x] + "]"
            console.log(ownGuaName);
            //农历月、日
            this.setData({
                changeMarkHide: true,
                ownGua: naJiaNameArr[xyObj.x][xyObj.y] + guiYouStr,
                ownGuaP: baGuaArr[xyObj.x],
                ownGuaBody: "卦身 (" + dzArr[guaBodyIndex] + ")",
                changeGua: '',
                changeGuaP: '',
                changeGuaBody: '',
                nameList: allObjNameList
            })
            console.log(ownGuaName);
        } else {
            var guiYouStr = ''
            if (xyObj.y == 6) {
                guiYouStr = "(游魂)"
            } else if (xyObj.y == 7) {
                guiYouStr = "(归魂)"
            }
            var guiYouCStr = ''
            if (changeXyObj.y == 6) {
                guiYouCStr = "(游魂)"
            } else if (changeXyObj.y == 7) {
                guiYouCStr = "(归魂)"
            }
            ownGuaName = naJiaNameArr[xyObj.x][xyObj.y] + guiYouStr + "[" + baGuaArr[xyObj.x] + "]"
            console.log(ownGuaName);
            changeGuaName = naJiaNameArr[changeXyObj.x][changeXyObj.y] + guiYouCStr + "[" + baGuaArr[changeXyObj.x] + "]"
            console.log(changeGuaName);
            //农历月、日
            this.setData({
                changeMarkHide: false,
                ownGua: naJiaNameArr[xyObj.x][xyObj.y] + guiYouStr,
                ownGuaP: baGuaArr[xyObj.x],
                ownGuaBody: "卦身 (" + dzArr[guaBodyIndex] + ")",
                changeGua: naJiaNameArr[changeXyObj.x][changeXyObj.y] + guiYouCStr,
                changeGuaP: baGuaArr[changeXyObj.x],
                changeGuaBody: "卦身 (" + dzArr[changeGuaBodyIndex] + ")",
                nameList: allObjNameList,
            })
            console.log(ownGuaName + " ~ " + changeGuaName);
        }
    },
    getEmpty: function (ob) {
        //通过ob中的dayNum获取旬空
        var dayNum = ob.dayNum
        //旬空,根据日来进行
        var empty = parseInt(dayNum / 10)
        return empty
    },
    getShaList: function (ob) {
        var shaList = []
        var shaListItem = null
        var shaObj = null
        var dayG = 0
        var dayZ = 0
        var monthZ = 0
        dayG = tgArr.indexOf(ob.bz_jr.substr(0, 1))
        dayZ = dzArr.indexOf(ob.bz_jr.substr(1, 1))
        monthZ = dzArr.indexOf(ob.bz_jy.substr(1, 1))

        var len = xingShaArr.length
        for (var i = 0; i < len; i++) {
            shaObj = new Object()
            if (xingShaRule[i].type == 0) {
                shaObj = this.getShaObj(i, shaObj, dayG)
            } else if (xingShaRule[i].type == 1) {
                shaObj = this.getShaObj(i, shaObj, dayZ)
            } else if (xingShaRule[i].type == 3) {
                shaObj = this.getShaObj(i, shaObj, monthZ)
            }

            if(i < 7){
                shaListItem = []
                shaListItem.push(shaObj)
                shaList[i % 7] = shaListItem
            }else if( i > 6){
                shaList[i % 7].push(shaObj)
            }
        }
        this.setData({
            shaList: shaList
        })
        console.log("#############################");
    },
    getShaObj: function (i, shaObj, typeNum) {
        var ganZhi = xingShaRule[i].ganZhi
        var ganZhiLen = ganZhi.length
        for (var n = 0; n < ganZhiLen; n++) {
            if (ganZhi[n].indexOf(typeNum) > -1) {
                shaObj.shaName = xingShaArr[i]
                var shaZhi = xingShaRule[i].shaZhi[n]
                if (shaZhi.length == 1) {
                    shaObj.shaZhi = dzArr[xingShaRule[i].shaZhi[n]]
                } else if (shaZhi.length == 2) {
                    shaObj.shaZhi = dzArr[xingShaRule[i].shaZhi[n][0]] + dzArr[xingShaRule[i].shaZhi[n][1]]
                }
            }
        }
        return shaObj
    },
    getSixBeast: function (ob) {
        //初始化开始天
        var sixGodList = []
        var dayG = 0
        var startNum = 0
        //通过日干支获取日的天干，然后获取下标数字
        dayG = tgArr.indexOf(ob.bz_jr.substr(0, 1))
        //六神
        //甲乙青龙、丙丁朱雀、戊勾陈、己朱雀、庚辛白虎、壬癸玄武
        if (dayG == 0 || dayG == 1) {
            startNum = 0
        } else if (dayG == 2 || dayG == 3) {
            startNum = 1
        } else if (dayG == 4) {
            startNum = 2
        } else if (dayG == 5) {
            startNum = 3
        } else if (dayG == 6 || dayG == 7) {
            startNum = 4
        } else if (dayG == 8 || dayG == 9) {
            startNum = 5
        }

        //六神
        for (let i = 0; i < 6; i++) {
            sixGodList[i] = startNum
            if (startNum < 5) {
                startNum++
            } else {
                startNum = 0
            }
        }
        //因为六兽从上往下排列时逆序的
        sixGodList = sixGodList.reverse()
        return sixGodList
    },
    getSixFourGua: function () {
        // 100000
        var startNum = 32
        // 111000
        var endNum = 56

        for (var i = 0; i < n; i++) {
            var mainGua = n - i - 1
            var one = (mainGua << 3) ^ mainGua
            var next = one
            sixFourList[i] = []
            sixFourList[i][0] = next
            // console.log("值:" + next + " " + next.toString(2));
            for (var j = 1; j < n; j++) {
                if (j < 7) {
                    next = next ^ (startNum >> shiYingArr[j])
                } else {
                    next = next ^ endNum
                }
                sixFourList[i][j] = next
                // console.log("值:" + next + " " + next.toString(2));
            }
        }
        return sixFourList
    },
    getOwnYaoList: function (yaoList) {
        //所有爻的数组
        var yaoListArr = []
        //开始纳甲
        if (yaoList) {
            //获取上一个页面传入的值
            //逆排序，从上到下进行遍历更方便
            console.log(yaoList);
            yaoListArr = yaoList.slice().reverse()
            console.log(yaoListArr);
        }
        return yaoListArr
    },
    getGongYaoList: function (x, sixFourList) {
        //所有爻的数组
        var gongYaoList = []
        var num = sixFourList[x][0]
        console.log(num);
        var numStr = this.numberToBinary(num, 6)
        console.log(numStr);

        for (var i = 0; i < 6; i++) {
            //逆排序，当前个位是六爻，要变成六爻为list第一个
            var yaoNum = parseInt(numStr.substr(i, 1))
            yaoNum = (yaoNum == 0) ? 2 : 1
            gongYaoList[5 - i] = yaoNum
        }
        console.log(gongYaoList);
        return gongYaoList
    },
    numberToBinary: function (num, length) {
        // 整数类型的位数
        var number_bit = length;
        var result = '';

        for (var i = number_bit - 1; i >= 0; i--) {
            // 让 1 左移的位数
            var mask = 1 << i;
            if ((mask & num) == 0) {
                result += '0';
            } else {
                result += '1';
            }
        }
        return result;
    },
    getChangeYaoList: function (yaoList) {
        //所有爻的数组
        var changeYaoList = []
        for (var i = 0; i < yaoList.length; i++) {
            if (yaoList[i] == 0) {
                changeYaoList[i] = 1
            } else if (yaoList[i] == 3) {
                changeYaoList[i] = 2
            } else {
                changeYaoList[i] = yaoList[i]
            }
        }
        return changeYaoList
    },
    getYaoImage: function (yaoList) {
        var yaoImageObj = new Object()
        //是否有变卦
        var isChangeFlag = false
        //获取爻象的数组
        var yaoImageList = [[]]
        //获取动爻的数组
        var changeList = []
        //获取爻的卦象
        for (var i = 0; i < yaoList.length; i++) {
            var yaoImage = []
            //判断爻象
            if (yaoList[i] % 2 == 0) {
                yaoImage[0] = "■";
                yaoImage[1] = " ";
                yaoImage[2] = "■";
            } else if (yaoList[i] % 2 == 1) {
                yaoImage[0] = "■";
                yaoImage[1] = "■";
                yaoImage[2] = "■";
            }
            yaoImageList[i] = yaoImage

            //判断动爻
            if (yaoList[i] == 0) {
                changeList[i] = "X"
                isChangeFlag = true
            } else if (yaoList[i] == 3) {
                changeList[i] = "O"
                isChangeFlag = true
            } else {
                changeList[i] = " "
            }
        }
        yaoImageObj.yaoImageList = yaoImageList
        yaoImageObj.changeList = changeList
        yaoImageObj.isChangeFlag = isChangeFlag
        return yaoImageObj
    },
    getYaoNum: function (yaoList) {
        var yaoNumObj = new Object()
        //获取卦象根据二进制获取数值
        var waiGuaStr = ((yaoList[2] % 2) + "") + ((yaoList[1] % 2) + "") + ((yaoList[0] % 2) + "")
        var neiGuaStr = ((yaoList[5] % 2) + "") + ((yaoList[4] % 2) + "") + ((yaoList[3] % 2) + "")
        var guaStr = neiGuaStr.toString() + waiGuaStr.toString()
        console.log("外卦的二进制：" + waiGuaStr)
        console.log("内卦的二进制：" + neiGuaStr)
        console.log("卦的二进制：" + guaStr)

        //获取外卦、内卦的二进制
        var waiGua = 7 - parseInt(waiGuaStr, 2)
        var neiGua = 7 - parseInt(neiGuaStr, 2)
        var guaNum = parseInt(guaStr, 2)
        console.log("外卦的数字，从0开始：" + waiGua)
        console.log("内卦的数字，从0开始：" + neiGua)
        console.log("卦的数字：" + guaNum)

        yaoNumObj.waiGua = waiGua
        yaoNumObj.neiGua = neiGua
        yaoNumObj.guaNum = guaNum
        return yaoNumObj
    },
    getXYByNum: function (guaNum) {
        var xyObj = new Object()
        var x, y
        for (var i = 0; i < n; i++) {
            for (var j = 0; j < n; j++) {
                if (sixFourList[i][j] == guaNum) {
                    x = i
                    y = j
                    break
                }
            }
        }
        xyObj.x = x
        xyObj.y = y
        return xyObj
    },
    getShiYingList: function (y) {
        var shiYingList = []
        var shiNum = 5 - shiYingArr[y]
        var yingNum = shiNum < 3 ? shiNum + 3 : shiNum - 3
        for (var i = 0; i < 6; i++) {
            if (i == shiNum) {
                shiYingList[i] = "世"
            } else if (i == yingNum) {
                shiYingList[i] = "应"
            } else {
                shiYingList[i] = " "
            }
        }
        return shiYingList
    },
    getGuaBody: function (yaoList, y) {
        var guaBodyIndex
        var shiNum = 5 - shiYingArr[y]
        if (yaoList[shiNum] % 2 == 0) {
            //确定卦身
            guaBodyIndex = 5 - shiNum + 6
        } else {
            guaBodyIndex = 5 - shiNum
        }
        return guaBodyIndex
    },
    getNaJiaObj: function (x, neiGua, waiGua) {
        //获取本宫属性，用x
        var gongP = baGuaPArr[x]
        //获取本宫五行属性的index
        var gongPIndex = this.getIndex(wuXingArr, gongP)

        var naJiaObj = {
            //纳甲天干list
            //纳甲地支list
            //纳甲五行list
            ganList: [],
            zhiList: [],
            wxList: [],
            sixQinList: [],
            gongPIndex: gongPIndex
        }

        //内卦干支
        var nGan = baGuaNaJiaArr.indexOf(baGuaArr[neiGua])
        //内卦开始的地支
        var startZhi
        //不同的天干的起始不一样
        startZhi = this.getStartZhi(nGan)
        //是否顺时针
        var ascFlag
        //如果偶数，则为阳，则顺排序
        ascFlag = startZhi % 2 == 0 ? true : false

        this.getGanZhiWxSqList(0, 3, nGan, ascFlag, startZhi, naJiaObj)

        //外卦干支，从第二个开始查找
        var wGan = baGuaNaJiaArr.indexOf(baGuaArr[waiGua], 2)
        //如果大于7，则减去8，回归0，1
        nGan = wGan > 7 ? wGan - 8 : wGan
        //外卦开始的地支
        startZhi = this.getStartZhi(nGan)
        //找出相冲的地支
        startZhi = startZhi < 7 ? startZhi + 6 : startZhi - 6
        //如果偶数，则为阳，则顺排序
        ascFlag = startZhi % 2 == 0 ? true : false

        this.getGanZhiWxSqList(3, 6, wGan, ascFlag, startZhi, naJiaObj)

        naJiaObj.ganList = naJiaObj.ganList.reverse()
        naJiaObj.zhiList = naJiaObj.zhiList.reverse()
        naJiaObj.wxList = naJiaObj.wxList.reverse()
        naJiaObj.sixQinList = naJiaObj.sixQinList.reverse()

        return naJiaObj
    },
    getStartZhi: function (gan) {
        var startZhi
        //不同的天干的起始不一样
        if (gan < 2 || gan > 5) {
            startZhi = gan < 6 ? gan + 6 : gan - 6
            startZhi = (startZhi == 6) ? 0 : startZhi
        } else if (gan == 2 || gan == 3) {
            startZhi = gan + 2
        } else if (gan == 4 || gan == 5) {
            startZhi = gan - 2
        }
        return startZhi
    },
    getGanZhiWxSqList: function (m, n, gan, ascFlag, startZhi, naJiaObj) {
        for (var i = m, startNum = 0; i < n; i++) {
            //纳入天干
            naJiaObj.ganList[i] = gan
            //间隔2进行增长
            var zhiNum = startZhi + startNum
            //小于0则加12，如果等于12则为0
            zhiNum = zhiNum < 0 ? zhiNum + 12 : zhiNum % 12
            //纳入地支
            naJiaObj.zhiList[i] = zhiNum
            //获取地支五行
            naJiaObj.wxList[i] = wuXingArr.indexOf(dzPArr[naJiaObj.zhiList[i]])
            //获取五行
            naJiaObj.sixQinList[i] = this.getSixQin(naJiaObj.gongPIndex, naJiaObj.wxList[i])
            //每次都间隔2
            startNum = ascFlag ? startNum + 2 : startNum - 2
        }
    },
    getSixQin: function (gongPIndex, zhiWxIndex) {
        return (5 - (gongPIndex - zhiWxIndex)) % 5
    },
    getIndex: function (arr, proper) {
        for (let i = 0; i < 5; i++) {
            if (arr[i] == proper) {
                return i
            }
        }
    },
    getFuShenList: function (gongNaJiaObj, naJiaObj) {
        var fuShenObj = {
            //nameList: [],
            ganList: [],
            zhiList: [],
            wxList: [],
            sixQinList: []
        }
        for (var i = 0; i < 6; i++) {
            if (naJiaObj.wxList.indexOf(gongNaJiaObj.wxList[i]) < 0) {
                fuShenObj.ganList[i] = gongNaJiaObj.ganList[i]
                fuShenObj.zhiList[i] = gongNaJiaObj.zhiList[i]
                fuShenObj.wxList[i] = gongNaJiaObj.wxList[i]
                fuShenObj.sixQinList[i] = gongNaJiaObj.sixQinList[i]
            } else {
                fuShenObj.ganList[i] = null
                fuShenObj.zhiList[i] = null
                fuShenObj.wxList[i] = null
                fuShenObj.sixQinList[i] = null
            }
        }
        return fuShenObj
    },
    getListName: function (obj) {
        var allObjList = new Array()
        var json
        for (let i = 0; i < 6; i++) {
            json = new Object()
            json.sqId = i
            json.sixGod = sixGodArr[obj.sixGodList[i]]
            json.yaoQin = yongShenArr[obj.sixQinList[i]]
            json.yaoGan = tgArr[obj.ganList[i]]
            json.yaoZhi = dzArr[obj.zhiList[i]]
            json.yaoWx = wuXingArr[obj.wxList[i]]
            json.yaoImage = obj.yaoImageList[i]
            json.shi = obj.shiYingList[i]
            json.change = obj.changeList[i]
            json.kong = kongArr[obj.kongList0[i]]
            json.yue = chongArr[obj.yueList0[i]]
            json.yueW = keArr[obj.yueWList0[i]]
            json.ri = chongArr[obj.riList0[i]]
            json.riW = keArr[obj.riWList0[i]]
            json.tlv = tlvArr[obj.tlvList0[i]]

            if (obj.FganList && obj.FganList[i] != null) {
                json.FQin = yongShenArr[obj.FsixQinList[i]]
                json.FGan = tgArr[obj.FganList[i]]
                json.FZhi = dzArr[obj.FzhiList[i]]
                json.FWx = wuXingArr[obj.FwxList[i]]
                json.Fkong = kongArr[obj.kongList1[i]]
                json.Fyue = chongArr[obj.yueList1[i]]
                json.FyueW = keArr[obj.yueWList1[i]]
                json.Fri = chongArr[obj.riList1[i]]
                json.FriW = keArr[obj.riWList1[i]]
                json.Ftlv = tlvArr[obj.tlvList1[i]]
                json.FImage = obj.FyaoImageList[i]
            }

            if (obj.CganList && obj.CganList[i] != null) {
                json.CQin = yongShenArr[obj.CsixQinList[i]]
                json.CGan = tgArr[obj.CganList[i]]
                json.CZhi = dzArr[obj.CzhiList[i]]
                json.CWx = wuXingArr[obj.CwxList[i]]
                json.CImage = obj.CyaoImageList[i]
                json.CShi = obj.CshiYingList[i]
                //如果没有动爻，则不显示
                // if (obj.changeList[i] != " ") {
                json.Ckong = kongArr[obj.kongList2[i]]
                json.Cyue = chongArr[obj.yueList2[i]]
                json.CyueW = keArr[obj.yueWList2[i]]
                json.Cri = chongArr[obj.riList2[i]]
                json.CriW = keArr[obj.riWList2[i]]
                json.Ctlv = tlvArr[obj.tlvList2[i]]
                // }
            }

            json.fb = htArr[obj.fbList[i]]
            allObjList[i] = json
        }
        return allObjList
    },
    getMarkList: function (obj) {
        //获取旬空的list
        obj.kongList0 = this.getKongList(obj.emptyList, obj.zhiList)
        obj.kongList1 = this.getKongList(obj.emptyList, obj.FzhiList)
        obj.kongList2 = this.getKongList(obj.emptyList, obj.CzhiList)

        //获取月冲合的list
        var yueObj0 = this.getYueList(obj.yue.zhi, obj.zhiList, obj.wxList)
        var yueObj1 = this.getYueList(obj.yue.zhi, obj.FzhiList, obj.FwxList)
        var yueObj2 = this.getYueList(obj.yue.zhi, obj.CzhiList, obj.CwxList)

        obj.yueList0 = yueObj0.yueList
        obj.yueList1 = yueObj1.yueList
        obj.yueList2 = yueObj2.yueList

        //获取月五行的list
        obj.yueWList0 = yueObj0.yueWList
        obj.yueWList1 = yueObj1.yueWList
        obj.yueWList2 = yueObj2.yueWList

        //获取日冲合的list
        var riObj0 = this.getYueList(obj.ri.zhi, obj.zhiList, obj.wxList)
        var riObj1 = this.getYueList(obj.ri.zhi, obj.FzhiList, obj.FwxList)
        var riObj2 = this.getYueList(obj.ri.zhi, obj.CzhiList, obj.CwxList)

        obj.riList0 = riObj0.yueList
        obj.riList1 = riObj1.yueList
        obj.riList2 = riObj2.yueList

        //获取日五行的list
        obj.riWList0 = riObj0.yueWList
        obj.riWList1 = riObj1.yueWList
        obj.riWList2 = riObj2.yueWList

        //获取日长生的list
        obj.tlvList0 = this.getTlvList(obj.ri.zhi, obj.wxList)
        obj.tlvList1 = this.getTlvList(obj.ri.zhi, obj.FwxList)
        console.log(obj.tlvList1);
        obj.tlvList2 = this.getTlvList(obj.ri.zhi, obj.CwxList)

        //获取变爻化进化退的list
        obj.fbList = this.getFbList(obj.zhiList, obj.CzhiList, obj.changeList)
    },
    getKongList: function (emptyList, zhiList) {
        var kongList = []
        console.log(zhiList);
        for (var i = 0; i < 6; i++) {
            if (zhiList && emptyList.indexOf(zhiList[i]) > -1) {
                kongList[i] = 1
            } else {
                kongList[i] = 0
            }
        }
        return kongList
    },
    getYueList: function (zhi, zhiList, wuList) {
        var yueObj = new Object()
        var yueList = []
        var yueWList = []
        for (var i = 0; i < 6; i++) {
            if (zhiList) {
                var zhiObj = zhiList[i]
                var zhiWx = wuXingArr.indexOf(dzPArr[zhi])
                //旺相休囚死
                yueWList[i] = (5 - (zhiWx - wuList[i])) % 5
                //值
                if (zhiObj == zhi) {
                    yueList[i] = 0
                    //临
                } else if (Math.abs(zhiObj - zhi) != 6 && dzPArr[zhiObj] == dzPArr[zhi]) {
                    yueList[i] = 1
                    //合
                } else if ((zhiObj + zhi) % 12 == 1) {
                    yueList[i] = 2
                    //冲
                } else if (Math.abs(zhiObj - zhi) == 6) {
                    yueList[i] = 3
                } else {
                    yueList[i] = null
                }
            }
        }
        yueObj.yueList = yueList
        yueObj.yueWList = yueWList
        return yueObj
    },
    getTlvList: function (zhi, wxList) {
        var tlvList = []
        for (var i = 0; i < 6; i++) {
            if (wxList && wxList[i] != null) {
                var offset = zhi - startTlvArr[wxList[i]]
                tlvList[i] = (offset < 0) ? offset + 12 : offset
            } else {
                tlvList[i] = null
            }
        }
        return tlvList
    },
    getFbList: function (zhiList, CzhiList, changeList) {
        var fbList = []
        for (var i = 0; i < 6; i++) {
            if (changeList[i] != " ") {
                var rOne = zhiList[i]
                var rTwo = CzhiList[i]
                var one = zhiList[i] < 2 ? zhiList[i] + 12 : zhiList[i]
                var two = CzhiList[i] < 2 ? CzhiList[i] + 12 : CzhiList[i]
                if (fbArr.indexOf(rOne) > -1 && two - rOne == 1) {
                    //进
                    fbList[i] = 0
                } else if (fbArr.indexOf(rTwo) > -1 && rTwo - one == -1) {
                    //退
                    fbList[i] = 1
                } else if (fkArr.indexOf(rOne) > -1 && two - rOne == 3) {
                    //进
                    fbList[i] = 0
                } else if (fkArr.indexOf(rTwo) > -1 && rTwo - one == -3) {
                    //退
                    fbList[i] = 1
                } else if ((5 - (wuXingArr.indexOf(dzPArr[rTwo]) - wuXingArr.indexOf(dzPArr[rOne]))) % 5 == 1) {
                    //生
                    fbList[i] = 2
                } else if ((5 - (wuXingArr.indexOf(dzPArr[rTwo]) - wuXingArr.indexOf(dzPArr[rOne]))) % 5 == 2) {
                    //克
                    fbList[i] = 3
                } else if ((rOne + rTwo) % 12 == 1) {
                    //合
                    fbList[i] = 4
                } else if (Math.abs(rOne - rTwo) == 6) {
                    //冲
                    fbList[i] = 5
                } else {
                    fbList[i] = null
                }
            } else {
                fbList[i] = null
            }
        }
        return fbList
    },
    save: function () {
        this.setData({
            saveHide: true,
            addHide: false
        })
    },
    getInputValue: function (e) {
        this.setData({
            input: e.detail.value
        })
    },
    containsList: function (list, str) {
        for (var i = 0; i < list.length; i++) {
            if (list[i].substr(0, 4).indexOf(str) > -1) {
                return list[i]
            }
        }
    },
    compareList: function (list, str) {
        for (var i = 0; i < list.length; i++) {
            if (list[i].split("（")[0].indexOf(str.split("(")[0]) > -1) {
                return list[i]
            }
        }
    },
    showDetail: function (e) {
        console.log(e.mark);
        var sMark = e.mark.smark
        var type = e.mark.type
        console.log(sMark);
        console.log(type);
        var title = ''

        if (sMark != undefined) {
            if (type == "sha") {
                title = shenShaNaYin[xingShaArr.indexOf(sMark)]
            } else if (type == "sixGod") {
                title = sixGodNaYin[sixGodArr.indexOf(sMark)]
            } else if (type == "sixQin") {
                title = sixQinNaYin[yongShenArr.indexOf(sMark)]
            } else if (type == "ganZhi") {
                var item = e.currentTarget.dataset.item
                console.log(item);
                var fMark = e.mark.fmark
                var ganZhi = ''
                if (fMark == "own") {
                    ganZhi = item.yaoGan + item.yaoZhi
                } else if (fMark == "fushen") {
                    ganZhi = item.FGan + item.FZhi
                } else if (fMark == "change") {
                    ganZhi = item.CGan + item.CZhi
                }
                title = this.containsList(ganZhiNaYin, ganZhi)
            } else if (type == "yaoNum") {
                var item = e.currentTarget.dataset.item
                console.log(item);
                title = yaoNumNaYin[item.sqId]
            } else if (type == "siZhu") {
                title = this.containsList(ganZhiNaYin, sMark)
            } else if (type == "yun") {
                title = yunNaYin[tlvArr.indexOf(sMark)]
            } else if (type == "guaName") {
                title = this.compareList(sixFourNaYin, sMark)
            }
            console.log(title);
            this.dialog.show(title);
        }
    }
})